// 性能和负载测试
describe('性能和负载测试', () => {
  beforeEach(() => {
    cy.login();
  });

  it('应该能够处理大量数据加载', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    
    // 测量页面加载性能
    cy.measurePerformance('页面加载', () => {
      cy.waitForLoading();
    });
    
    // 验证大量数据加载
    cy.get('@页面加载Duration').then((duration) => {
      expect(duration).to.be.lessThan(5000); // 5秒内加载完成
    });
  });

  it('应该能够快速响应搜索操作', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    cy.waitForLoading();
    
    // 测量搜索响应时间
    cy.measurePerformance('搜索响应', () => {
      cy.searchInTable('测试');
      cy.waitForLoading();
    });
    
    // 验证搜索性能
    cy.get('@搜索响应Duration').then((duration) => {
      expect(duration).to.be.lessThan(2000); // 2秒内响应
    });
  });

  it('应该能够高效处理表单提交', () => {
    // 访问创建智能体页面
    cy.visit('/agents/create');
    
    // 测量表单提交性能
    cy.measurePerformance('表单提交', () => {
      const testData = cy.getTestData().agent;
      cy.fillForm(testData);
      cy.get('[data-cy="submit-button"]').click();
    });
    
    // 验证提交性能
    cy.get('@表单提交Duration').then((duration) => {
      expect(duration).to.be.lessThan(3000); // 3秒内提交完成
    });
  });

  it('应该能够快速切换页面', () => {
    // 测量页面切换性能
    cy.measurePerformance('页面切换', () => {
      cy.visit('/agents');
      cy.waitForLoading();
      cy.visit('/model-configs');
      cy.waitForLoading();
      cy.visit('/conversations');
      cy.waitForLoading();
    });
    
    // 验证切换性能
    cy.get('@页面切换Duration').then((duration) => {
      expect(duration).to.be.lessThan(8000); // 8秒内完成所有切换
    });
  });

  it('应该能够高效处理数据导出', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    cy.waitForLoading();
    
    // 测量导出性能
    cy.measurePerformance('数据导出', () => {
      cy.get('[data-cy="export-button"]').click();
      cy.selectDropdownItem('[data-cy="export-menu"]', 'JSON');
    });
    
    // 验证导出性能
    cy.get('@数据导出Duration').then((duration) => {
      expect(duration).to.be.lessThan(5000); // 5秒内导出完成
    });
  });

  it('应该能够快速处理模态框操作', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    cy.waitForLoading();
    
    // 测量模态框性能
    cy.measurePerformance('模态框操作', () => {
      cy.get('[data-cy="create-agent-button"]').click();
      cy.shouldHaveModal('创建智能体');
      cy.closeModal();
    });
    
    // 验证模态框性能
    cy.get('@模态框操作Duration').then((duration) => {
      expect(duration).to.be.lessThan(2000); // 2秒内完成模态框操作
    });
  });

  it('应该能够高效处理表格排序', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    cy.waitForLoading();
    
    // 测量排序性能
    cy.measurePerformance('表格排序', () => {
      cy.get('[data-cy="sort-name"]').click();
      cy.waitForLoading();
      cy.get('[data-cy="sort-created"]').click();
      cy.waitForLoading();
    });
    
    // 验证排序性能
    cy.get('@表格排序Duration').then((duration) => {
      expect(duration).to.be.lessThan(3000); // 3秒内完成排序
    });
  });

  it('应该能够快速处理分页操作', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    cy.waitForLoading();
    
    // 测量分页性能
    cy.measurePerformance('分页操作', () => {
      cy.goToPage(2);
      cy.waitForLoading();
      cy.goToPage(3);
      cy.waitForLoading();
    });
    
    // 验证分页性能
    cy.get('@分页操作Duration').then((duration) => {
      expect(duration).to.be.lessThan(4000); // 4秒内完成分页
    });
  });

  it('应该能够高效处理文件上传', () => {
    // 访问文件上传页面
    cy.visit('/files/upload');
    
    // 测量文件上传性能
    cy.measurePerformance('文件上传', () => {
      cy.uploadFile('[data-cy="file-input"]', 'test-file.txt', 'text/plain');
      cy.get('[data-cy="upload-button"]').click();
    });
    
    // 验证上传性能
    cy.get('@文件上传Duration').then((duration) => {
      expect(duration).to.be.lessThan(10000); // 10秒内上传完成
    });
  });

  it('应该能够快速处理图表渲染', () => {
    // 访问监控仪表板
    cy.visit('/dashboard');
    cy.waitForLoading();
    
    // 测量图表渲染性能
    cy.measurePerformance('图表渲染', () => {
      cy.get('[data-cy="performance-chart"]').should('be.visible');
      cy.get('[data-cy="usage-chart"]').should('be.visible');
      cy.get('[data-cy="error-rate-chart"]').should('be.visible');
    });
    
    // 验证图表渲染性能
    cy.get('@图表渲染Duration').then((duration) => {
      expect(duration).to.be.lessThan(3000); // 3秒内渲染完成
    });
  });

  it('应该能够高效处理实时数据更新', () => {
    // 访问实时监控页面
    cy.visit('/monitoring/real-time');
    cy.waitForLoading();
    
    // 测量实时更新性能
    cy.measurePerformance('实时更新', () => {
      cy.wait(5000); // 等待5秒观察实时更新
    });
    
    // 验证实时更新性能
    cy.get('@实时更新Duration').then((duration) => {
      expect(duration).to.be.lessThan(6000); // 6秒内完成更新
    });
  });

  it('应该能够快速处理批量操作', () => {
    // 访问智能体列表页面
    cy.visit('/agents');
    cy.waitForLoading();
    
    // 测量批量操作性能
    cy.measurePerformance('批量操作', () => {
      cy.get('[data-cy="select-all-checkbox"]').check();
      cy.get('[data-cy="batch-enable"]').click();
      cy.confirmModal();
    });
    
    // 验证批量操作性能
    cy.get('@批量操作Duration').then((duration) => {
      expect(duration).to.be.lessThan(4000); // 4秒内完成批量操作
    });
  });

  it('应该能够高效处理搜索建议', () => {
    // 访问搜索页面
    cy.visit('/search');
    
    // 测量搜索建议性能
    cy.measurePerformance('搜索建议', () => {
      cy.get('[data-cy="search-input"]').type('智能');
      cy.get('[data-cy="search-suggestions"]').should('be.visible');
    });
    
    // 验证搜索建议性能
    cy.get('@搜索建议Duration').then((duration) => {
      expect(duration).to.be.lessThan(1000); // 1秒内显示建议
    });
  });

  it('应该能够快速处理数据验证', () => {
    // 访问创建智能体页面
    cy.visit('/agents/create');
    
    // 测量数据验证性能
    cy.measurePerformance('数据验证', () => {
      cy.get('[data-cy="submit-button"]').click();
      cy.shouldHaveFormError('[data-cy="name-field"]', '请输入智能体名称');
    });
    
    // 验证数据验证性能
    cy.get('@数据验证Duration').then((duration) => {
      expect(duration).to.be.lessThan(1000); // 1秒内完成验证
    });
  });

  it('应该能够高效处理权限检查', () => {
    // 测量权限检查性能
    cy.measurePerformance('权限检查', () => {
      cy.visit('/admin/users');
      cy.waitForLoading();
    });
    
    // 验证权限检查性能
    cy.get('@权限检查Duration').then((duration) => {
      expect(duration).to.be.lessThan(2000); // 2秒内完成权限检查
    });
  });

  it('应该能够快速处理缓存操作', () => {
    // 访问缓存管理页面
    cy.visit('/admin/cache');
    
    // 测量缓存操作性能
    cy.measurePerformance('缓存操作', () => {
      cy.get('[data-cy="clear-cache"]').click();
      cy.confirmModal();
    });
    
    // 验证缓存操作性能
    cy.get('@缓存操作Duration').then((duration) => {
      expect(duration).to.be.lessThan(2000); // 2秒内完成缓存操作
    });
  });

  it('应该能够高效处理并发请求', () => {
    // 模拟并发请求
    const requests = [];
    for (let i = 0; i < 5; i++) {
      requests.push(
        cy.intercept('GET', '/api/agents', {
          statusCode: 200,
          body: { items: [] },
        }).as(`getAgents${i}`)
      );
    }
    
    // 测量并发请求性能
    cy.measurePerformance('并发请求', () => {
      cy.visit('/agents');
      requests.forEach((_, index) => {
        cy.waitForApiResponse(`@getAgents${index}`);
      });
    });
    
    // 验证并发请求性能
    cy.get('@并发请求Duration').then((duration) => {
      expect(duration).to.be.lessThan(5000); // 5秒内处理所有并发请求
    });
  });

  it('应该能够快速处理错误恢复', () => {
    // 模拟错误
    cy.intercept('GET', '/api/agents', {
      statusCode: 500,
      body: { message: '服务器错误' },
    }).as('serverError');
    
    // 测量错误恢复性能
    cy.measurePerformance('错误恢复', () => {
      cy.visit('/agents');
      cy.waitForApiResponse('@serverError');
      cy.shouldHaveErrorMessage('服务器错误');
      cy.get('[data-cy="retry-button"]').click();
    });
    
    // 验证错误恢复性能
    cy.get('@错误恢复Duration').then((duration) => {
      expect(duration).to.be.lessThan(3000); // 3秒内完成错误恢复
    });
  });

  it('应该能够高效处理动画效果', () => {
    // 访问带有动画的页面
    cy.visit('/dashboard');
    cy.waitForLoading();
    
    // 测量动画性能
    cy.measurePerformance('动画效果', () => {
      cy.waitForAnimations();
    });
    
    // 验证动画性能
    cy.get('@动画效果Duration').then((duration) => {
      expect(duration).to.be.lessThan(1000); // 1秒内完成动画
    });
  });

  it('应该能够快速处理响应式布局', () => {
    // 测试不同屏幕尺寸
    const viewports = [
      { width: 1920, height: 1080 },
      { width: 1366, height: 768 },
      { width: 768, height: 1024 },
      { width: 375, height: 667 },
    ];
    
    // 测量响应式布局性能
    cy.measurePerformance('响应式布局', () => {
      cy.testResponsiveLayout(viewports);
    });
    
    // 验证响应式布局性能
    cy.get('@响应式布局Duration').then((duration) => {
      expect(duration).to.be.lessThan(5000); // 5秒内完成响应式布局测试
    });
  });

  it('应该能够高效处理国际化切换', () => {
    // 访问设置页面
    cy.visit('/settings');
    
    // 测量国际化切换性能
    cy.measurePerformance('国际化切换', () => {
      cy.get('[data-cy="language-switch"]').click();
      cy.get('[data-cy="language-en"]').click();
      cy.get('[data-cy="language-switch"]').click();
      cy.get('[data-cy="language-zh"]').click();
    });
    
    // 验证国际化切换性能
    cy.get('@国际化切换Duration').then((duration) => {
      expect(duration).to.be.lessThan(2000); // 2秒内完成语言切换
    });
  });

  it('应该能够快速处理主题切换', () => {
    // 访问设置页面
    cy.visit('/settings');
    
    // 测量主题切换性能
    cy.measurePerformance('主题切换', () => {
      cy.get('[data-cy="theme-switch"]').click();
      cy.get('[data-cy="theme-dark"]').click();
      cy.get('[data-cy="theme-switch"]').click();
      cy.get('[data-cy="theme-light"]').click();
    });
    
    // 验证主题切换性能
    cy.get('@主题切换Duration').then((duration) => {
      expect(duration).to.be.lessThan(2000); // 2秒内完成主题切换
    });
  });

  it('应该能够高效处理数据同步', () => {
    // 访问数据同步页面
    cy.visit('/admin/sync');
    
    // 测量数据同步性能
    cy.measurePerformance('数据同步', () => {
      cy.get('[data-cy="sync-button"]').click();
      cy.confirmModal();
    });
    
    // 验证数据同步性能
    cy.get('@数据同步Duration').then((duration) => {
      expect(duration).to.be.lessThan(10000); // 10秒内完成数据同步
    });
  });

  it('应该能够快速处理日志查询', () => {
    // 访问日志查询页面
    cy.visit('/admin/logs');
    
    // 测量日志查询性能
    cy.measurePerformance('日志查询', () => {
      cy.fillForm({
        'logLevel': 'ERROR',
        'dateRange': '2024-01-01,2024-01-31',
      });
      cy.get('[data-cy="search-button"]').click();
    });
    
    // 验证日志查询性能
    cy.get('@日志查询Duration').then((duration) => {
      expect(duration).to.be.lessThan(3000); // 3秒内完成日志查询
    });
  });
});